home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / ScreenPanel.c < prev    next >
C/C++ Source or Header  |  1995-09-28  |  42KB  |  1,636 lines
  1. /*
  2. **    ScreenPanel.c
  3. **
  4. **    Editing panel for screen configuration
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_SCREENMODE=1000,GAD_USE_PUBSCREEN,GAD_PUBSCREENNAME,GAD_FONT,
  13.         GAD_COLOURMODE,GAD_SCREENTITLE,GAD_MAKESCREENPUBLIC,GAD_SHANGHAI,
  14.         GAD_BLINKING,GAD_PALETTE,GAD_RED,GAD_GREEN,GAD_BLUE,GAD_RESET,
  15.         GAD_STDPENS,GAD_EDITPENS,GAD_WINDOW_BORDER,GAD_SPLIT_STATUS,
  16.         GAD_STATUS_LINE,GAD_PAGER,GAD_PAGEGROUP,
  17.  
  18.         GAD_USE,GAD_CANCEL,GAD_DEFAULT };
  19.  
  20.     /* CannotChangeColours(struct Configuration *LocalConfig,WORD OriginalColourMode):
  21.      *
  22.      *    This routine rolls the dice and determines whether the user should
  23.      *    be allowed to change the screen colours or rendering pens.
  24.      */
  25.  
  26. STATIC BOOL __regargs
  27. CannotChangeColours(struct Configuration *LocalConfig,WORD OriginalColourMode)
  28. {
  29.     if(LocalConfig -> ScreenConfig -> ColourMode == OriginalColourMode && !LocalConfig -> ScreenConfig -> UseWorkbench && LocalConfig -> ScreenConfig -> ColourMode == Config -> ScreenConfig -> ColourMode && Screen)
  30.     {
  31.         LONG ThisDepth,RequestedDepth;
  32.  
  33.         ThisDepth = GetBitMapDepth(Window -> WScreen -> RastPort . BitMap);
  34.  
  35.         switch(LocalConfig -> ScreenConfig -> ColourMode)
  36.         {
  37.             case COLOUR_AMIGA:
  38.  
  39.                 RequestedDepth = 2;
  40.                 break;
  41.  
  42.             case COLOUR_EIGHT:
  43.  
  44.                 RequestedDepth = 3;
  45.                 break;
  46.  
  47.             case COLOUR_SIXTEEN:
  48.  
  49.                 RequestedDepth = 4;
  50.                 break;
  51.  
  52.             case COLOUR_MONO:
  53.  
  54.                 RequestedDepth = 1;
  55.                 break;
  56.         }
  57.  
  58.         return((BOOL)(ThisDepth < RequestedDepth));
  59.     }
  60.     else
  61.         return(TRUE);
  62. }
  63.  
  64. STATIC BYTE  __regargs
  65. SelectDisplayMode(struct Window *Window,ULONG *CurrentMode,struct Configuration *Config)
  66. {
  67.     BYTE Success = FALSE;
  68.  
  69.     if(AslBase -> lib_Version < 38)
  70.     {
  71.         struct List    *ModeList;
  72.         LONG         Index;
  73.  
  74.         if(ModeList = BuildModeList(&Index,*CurrentMode,NULL))
  75.         {
  76.             struct LayoutHandle *Handle;
  77.  
  78.             if(Handle = LT_CreateHandleTags(Window -> WScreen,
  79.                 LH_LocaleHook,    &LocaleHook,
  80.             TAG_DONE))
  81.             {
  82.                 struct Window *LocalWindow;
  83.  
  84.                 LT_New(Handle,
  85.                     LA_Type,    VERTICAL_KIND,
  86.                 TAG_DONE);
  87.                 {
  88.                     LT_New(Handle,
  89.                         LA_Type,    VERTICAL_KIND,
  90.                     TAG_DONE);
  91.                     {
  92.                         LONG MaxWidth = -1,MaxHeight = 0,Len;
  93.                         struct Node *Node;
  94.  
  95.                         for(Node = ModeList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  96.                         {
  97.                             Len = strlen(Node -> ln_Name);
  98.  
  99.                             if(Len > MaxWidth)
  100.                                 MaxWidth = Len;
  101.  
  102.                             MaxHeight++;
  103.                         }
  104.  
  105.                         MaxHeight++;
  106.  
  107.                         LT_New(Handle,
  108.                             LA_Type,    LISTVIEW_KIND,
  109.                             LA_LabelID,    MSG_V36_0160,
  110.                             GTLV_Labels,    ModeList,
  111.                             LA_LONG,    &Index,
  112.                             LALV_CursorKey,    TRUE,
  113.                             LALV_Link,    NIL_LINK,
  114.                             LALV_MaxGrowY,    MaxHeight,
  115.                             LALV_ResizeY,    TRUE,
  116.                             LA_Lines,    MaxHeight > 10 ? 10 : MaxHeight,
  117.                             LA_Chars,    MaxWidth,
  118.                             LA_CursorKey,    TRUE,
  119.                         TAG_DONE);
  120.  
  121.                         LT_EndGroup(Handle);
  122.                     }
  123.  
  124.                     LT_New(Handle,
  125.                         LA_Type,VERTICAL_KIND,
  126.                     TAG_DONE);
  127.                     {
  128.                         LT_New(Handle,
  129.                             LA_Type,    XBAR_KIND,
  130.                             LAXB_FullSize,    TRUE,
  131.                         TAG_DONE);
  132.  
  133.                         LT_EndGroup(Handle);
  134.                     }
  135.  
  136.                     LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  137.                         LAGR_SameSize,    TRUE,
  138.                         LAGR_Spread,    TRUE,
  139.                     TAG_DONE);
  140.                     {
  141.                         LT_New(Handle,
  142.                             LA_Type,    BUTTON_KIND,
  143.                             LA_LabelID,    MSG_GLOBAL_USE_GAD,
  144.                             LA_ID,        GAD_USE,
  145.                             LABT_ReturnKey,    TRUE,
  146.                             LABT_ExtraFat,    TRUE,
  147.                         TAG_DONE);
  148.  
  149.                         LT_New(Handle,
  150.                             LA_Type,    BUTTON_KIND,
  151.                             LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  152.                             LA_ID,        GAD_CANCEL,
  153.                             LABT_EscKey,    TRUE,
  154.                             LABT_ExtraFat,    TRUE,
  155.                         TAG_DONE);
  156.  
  157.                         LT_EndGroup(Handle);
  158.                     }
  159.  
  160.                     LT_EndGroup(Handle);
  161.                 }
  162.  
  163.                 if(LocalWindow = LT_Build(Handle,
  164.                     LAWN_TitleID,        MSG_V36_0161,
  165.                     LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  166.                     LAWN_HelpHook,        &GuideHook,
  167.                     LAWN_Parent,        Window,
  168.                     WA_DepthGadget,        TRUE,
  169.                     WA_CloseGadget,        TRUE,
  170.                     WA_DragBar,        TRUE,
  171.                     WA_RMBTrap,        TRUE,
  172.                     WA_Activate,        TRUE,
  173.                     WA_SimpleRefresh,    TRUE,
  174.                 TAG_DONE))
  175.                 {
  176.                     struct IntuiMessage    *Message;
  177.                     BOOL             Done = FALSE;
  178.                     ULONG             MsgClass;
  179.                     struct Gadget        *MsgGadget;
  180.                     LONG             i;
  181.                     struct ModeNode        *ModeNode;
  182.  
  183.                     do
  184.                     {
  185.                         WaitPort(LocalWindow -> UserPort);
  186.  
  187.                         while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  188.                         {
  189.                             MsgClass    = Message -> Class;
  190.                             MsgGadget    = (struct Gadget *)Message -> IAddress;
  191.  
  192.                             LT_ReplyIMsg(Message);
  193.  
  194.                             if(MsgClass == IDCMP_CLOSEWINDOW)
  195.                                 Done = TRUE;
  196.  
  197.                             if(MsgClass == IDCMP_GADGETUP)
  198.                             {
  199.                                 switch(MsgGadget -> GadgetID)
  200.                                 {
  201.                                     case GAD_USE:
  202.  
  203.                                         for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  204.                                         {
  205.                                             if(Index == i)
  206.                                             {
  207.                                                 *CurrentMode = ModeNode -> DisplayID;
  208.  
  209.                                                 break;
  210.                                             }
  211.                                         }
  212.  
  213.                                         Success = Done = TRUE;
  214.                                         break;
  215.  
  216.                                     case GAD_CANCEL:
  217.  
  218.                                         Done = TRUE;
  219.                                         break;
  220.                                 }
  221.                             }
  222.  
  223.                             if(MsgClass == IDCMP_IDCMPUPDATE)
  224.                             {
  225.                                 for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  226.                                 {
  227.                                     if(Index == i)
  228.                                     {
  229.                                         *CurrentMode = ModeNode -> DisplayID;
  230.  
  231.                                         Success = Done = TRUE;
  232.  
  233.                                         LT_PressButton(Handle,GAD_USE);
  234.  
  235.                                         break;
  236.                                     }
  237.                                 }
  238.                             }
  239.                         }
  240.                     }
  241.                     while(!Done);
  242.  
  243.                     if(Success)
  244.                     {
  245.                         Config -> ScreenConfig -> Depth        = 0;
  246.                         Config -> ScreenConfig -> OverscanType    = OSCAN_TEXT;
  247.                         Config -> ScreenConfig -> DisplayWidth    = 0;
  248.                         Config -> ScreenConfig -> DisplayHeight    = 0;
  249.                     }
  250.                 }
  251.  
  252.                 LT_DeleteHandle(Handle);
  253.             }
  254.  
  255.             DeleteList(ModeList);
  256.         }
  257.     }
  258.     else
  259.     {
  260.         struct TagItem             DimensionTags[5];
  261.         struct ScreenModeRequester    *Request;
  262.         LONG                 DisplayWidth,
  263.                          DisplayHeight,
  264.                          Depth,
  265.                          MinDepth;
  266.         struct Rectangle         DisplayClip;
  267.  
  268.         Depth = Config -> ScreenConfig -> Depth;
  269.  
  270.         switch(Config -> ScreenConfig -> ColourMode)
  271.         {
  272.             case COLOUR_AMIGA:
  273.  
  274.                 MinDepth = 2;
  275.                 break;
  276.  
  277.             case COLOUR_EIGHT:
  278.  
  279.                 MinDepth = 3;
  280.                 break;
  281.  
  282.             case COLOUR_SIXTEEN:
  283.  
  284.                 MinDepth = 4;
  285.                 break;
  286.  
  287.             case COLOUR_MONO:
  288.  
  289.                 MinDepth = 1;
  290.                 break;
  291.         }
  292.  
  293.         if(Depth < MinDepth)
  294.             Depth = MinDepth;
  295.  
  296.         if((!Config -> ScreenConfig -> DisplayWidth || !Config -> ScreenConfig -> DisplayHeight) && QueryOverscan(Config -> ScreenConfig -> DisplayMode,&DisplayClip,Config -> ScreenConfig -> OverscanType))
  297.         {
  298.             DisplayWidth    = DisplayClip . MaxX - DisplayClip . MinX + 1;
  299.             DisplayHeight    = DisplayClip . MaxY - DisplayClip . MinY + 1;
  300.         }
  301.         else
  302.         {
  303.             DisplayWidth    = Config -> ScreenConfig -> DisplayWidth;
  304.             DisplayHeight    = Config -> ScreenConfig -> DisplayHeight;
  305.         }
  306.  
  307.         if(Request = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  308.             ASLSM_Window,            Window,
  309.             ASLSM_InitialDisplayID,        *CurrentMode,
  310.             ASLSM_PrivateIDCMP,        TRUE,
  311.             ASLSM_InitialDisplayDepth,    Depth,
  312.             ASLSM_MinDepth,            MinDepth,
  313.             ASLSM_MaxDepth,            8,
  314.             ASLSM_DoDepth,            TRUE,
  315.             ASLSM_DoWidth,            TRUE,
  316.             ASLSM_DoHeight,            TRUE,
  317.             ASLSM_DoOverscanType,        TRUE,
  318.             ASLSM_InitialOverscanType,    Config -> ScreenConfig -> OverscanType,
  319.  
  320.             DisplayWidth  ? ASLSM_InitialDisplayWidth  : TAG_IGNORE, DisplayWidth,
  321.             DisplayHeight ? ASLSM_InitialDisplayHeight : TAG_IGNORE, DisplayHeight,
  322.         TAG_DONE))
  323.         {
  324.             if(AslRequest(Request,GetDimensionTags(NULL,DimensionTags)))
  325.             {
  326.                 PutDimensionTags(Window,Request -> sm_LeftEdge,Request -> sm_TopEdge,Request -> sm_Width,Request -> sm_Height);
  327.  
  328.                 *CurrentMode = Request -> sm_DisplayID;
  329.  
  330.                 if(Request -> sm_DisplayDepth == MinDepth)
  331.                     Depth = 0;
  332.                 else
  333.                     Depth = Request -> sm_DisplayDepth;
  334.  
  335.                 Config -> ScreenConfig -> Depth        = Depth;
  336.                 Config -> ScreenConfig -> OverscanType    = Request -> sm_OverscanType;
  337.                 Config -> ScreenConfig -> DisplayWidth    = Request -> sm_DisplayWidth;
  338.                 Config -> ScreenConfig -> DisplayHeight    = Request -> sm_DisplayHeight;
  339.  
  340.                 Success = TRUE;
  341.             }
  342.  
  343.             FreeAslRequest(Request);
  344.         }
  345.     }
  346.  
  347.     return(Success);
  348. }
  349.  
  350. STATIC BOOLEAN __regargs
  351. PenPanel(struct Window *Window,UWORD *Array,UWORD *DefaultArray,WORD Depth)
  352. {
  353.     struct LayoutHandle    *Handle;
  354.     UWORD             PrivateArray[16];
  355.     BOOLEAN             Result = FALSE;
  356.  
  357.     CopyMem(Array,PrivateArray,sizeof(PrivateArray));
  358.  
  359.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  360.         LH_LocaleHook,    &LocaleHook,
  361.         LH_ExactClone,    TRUE,
  362.     TAG_DONE))
  363.     {
  364.         struct Window *PanelWindow;
  365.  
  366.         LT_New(Handle,
  367.             LA_Type,    VERTICAL_KIND,
  368.         TAG_DONE);
  369.         {
  370.             LT_New(Handle,
  371.                 LA_Type,    VERTICAL_KIND,
  372.                 LA_LabelID,    MSG_PENPANEL_DRAWING_PENS_TXT,
  373.             TAG_DONE);
  374.             {
  375.                 LT_New(Handle,
  376.                     LA_Type,    VERTICAL_KIND,
  377.                 TAG_DONE);
  378.                 {
  379.                     LT_New(Handle,
  380.                         LA_Type,        PALETTE_KIND,
  381.                         LA_LabelID,        MSG_PENPANEL_BACKGROUND_TXT,
  382.                         GTPA_Depth,        Depth,
  383.                         LAPA_SmallPalette,    TRUE,
  384.                         LA_UWORD,        &PrivateArray[BACKGROUNDPEN],
  385.                         LA_Chars,        15,
  386.                         LA_ID,            100 + BACKGROUNDPEN,
  387.                     TAG_DONE);
  388.  
  389.                     LT_New(Handle,
  390.                         LA_Type,        PALETTE_KIND,
  391.                         LA_LabelID,        MSG_PENPANEL_TEXT_TXT,
  392.                         GTPA_Depth,        Depth,
  393.                         LAPA_SmallPalette,    TRUE,
  394.                         LA_UWORD,        &PrivateArray[TEXTPEN],
  395.                         LA_ID,            100 + TEXTPEN,
  396.                     TAG_DONE);
  397.  
  398.                     LT_New(Handle,
  399.                         LA_Type,        PALETTE_KIND,
  400.                         LA_LabelID,        MSG_PENPANEL_IMPORTANT_TEXT_TXT,
  401.                         GTPA_Depth,        Depth,
  402.                         LAPA_SmallPalette,    TRUE,
  403.                         LA_UWORD,        &PrivateArray[HIGHLIGHTTEXTPEN],
  404.                         LA_ID,            100 + HIGHLIGHTTEXTPEN,
  405.                     TAG_DONE);
  406.  
  407.                     LT_New(Handle,
  408.                         LA_Type,        PALETTE_KIND,
  409.                         LA_LabelID,        MSG_PENPANEL_BRIGHT_EDGES_TXT,
  410.                         GTPA_Depth,        Depth,
  411.                         LAPA_SmallPalette,    TRUE,
  412.                         LA_UWORD,        &PrivateArray[SHINEPEN],
  413.                         LA_ID,            100 + SHINEPEN,
  414.                     TAG_DONE);
  415.  
  416.                     LT_New(Handle,
  417.                         LA_Type,        PALETTE_KIND,
  418.                         LA_LabelID,        MSG_PENPANEL_DARK_EDGES_TXT,
  419.                         GTPA_Depth,        Depth,
  420.                         LAPA_SmallPalette,    TRUE,
  421.                         LA_UWORD,        &PrivateArray[SHADOWPEN],
  422.                         LA_ID,            100 + SHADOWPEN,
  423.                     TAG_DONE);
  424.  
  425.                     LT_New(Handle,
  426.                         LA_Type,        PALETTE_KIND,
  427.                         LA_LabelID,        MSG_PENPANEL_FILLPEN_TXT,
  428.                         GTPA_Depth,        Depth,
  429.                         LAPA_SmallPalette,    TRUE,
  430.                         LA_UWORD,        &PrivateArray[FILLPEN],
  431.                         LA_ID,            100 + FILLPEN,
  432.                     TAG_DONE);
  433.  
  434.                     LT_New(Handle,
  435.                         LA_Type,        PALETTE_KIND,
  436.                         LA_LabelID,        MSG_PENPANEL_FILLTEXTPEN_TXT,
  437.                         GTPA_Depth,        Depth,
  438.                         LAPA_SmallPalette,    TRUE,
  439.                         LA_UWORD,        &PrivateArray[FILLTEXTPEN],
  440.                         LA_ID,            100 + FILLTEXTPEN,
  441.                     TAG_DONE);
  442.  
  443.                     LT_New(Handle,
  444.                         LA_Type,        PALETTE_KIND,
  445.                         LA_LabelID,        MSG_PENPANEL_BARFILLPEN_TXT,
  446.                         GTPA_Depth,        Depth,
  447.                         LAPA_SmallPalette,    TRUE,
  448.                         LA_UWORD,        &PrivateArray[BARBLOCKPEN],
  449.                         LA_ID,            100 + BARBLOCKPEN,
  450.                     TAG_DONE);
  451.  
  452.                     LT_New(Handle,
  453.                         LA_Type,        PALETTE_KIND,
  454.                         LA_LabelID,        MSG_PENPANEL_BARTEXTPEN_TXT,
  455.                         GTPA_Depth,        Depth,
  456.                         LAPA_SmallPalette,    TRUE,
  457.                         LA_UWORD,        &PrivateArray[BARDETAILPEN],
  458.                         LA_ID,            100 + BARDETAILPEN,
  459.                     TAG_DONE);
  460.  
  461.                     LT_EndGroup(Handle);
  462.                 }
  463.  
  464.                 LT_New(Handle,
  465.                     LA_Type,XBAR_KIND,
  466.                 TAG_DONE);
  467.  
  468.                 LT_New(Handle,
  469.                     LA_Type,    VERTICAL_KIND,
  470.                 TAG_DONE);
  471.                 {
  472.                     LT_New(Handle,
  473.                         LA_Type,    BUTTON_KIND,
  474.                         LA_LabelID,    MSG_PENPANEL_STANDARDPENS_TXT,
  475.                         LA_ID,        GAD_DEFAULT,
  476.                         LABT_ExtraFat,    TRUE,
  477.                     TAG_DONE);
  478.  
  479.                     LT_EndGroup(Handle);
  480.                 }
  481.  
  482.                 LT_EndGroup(Handle);
  483.             }
  484.  
  485.             LT_New(Handle,
  486.                 LA_Type,VERTICAL_KIND,
  487.             TAG_DONE);
  488.             {
  489.                 LT_New(Handle,
  490.                     LA_Type,    XBAR_KIND,
  491.                     LAXB_FullSize,    TRUE,
  492.                 TAG_DONE);
  493.  
  494.                 LT_EndGroup(Handle);
  495.             }
  496.  
  497.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  498.                 LAGR_SameSize,    TRUE,
  499.                 LAGR_Spread,    TRUE,
  500.             TAG_DONE);
  501.             {
  502.                 LT_New(Handle,
  503.                     LA_Type,    BUTTON_KIND,
  504.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  505.                     LA_ID,        GAD_USE,
  506.                     LABT_ReturnKey,    TRUE,
  507.                     LABT_ExtraFat,    TRUE,
  508.                 TAG_DONE);
  509.  
  510.                 LT_New(Handle,
  511.                     LA_Type,    BUTTON_KIND,
  512.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  513.                     LA_ID,        GAD_CANCEL,
  514.                     LABT_EscKey,    TRUE,
  515.                     LABT_ExtraFat,    TRUE,
  516.                 TAG_DONE);
  517.  
  518.                 LT_EndGroup(Handle);
  519.             }
  520.  
  521.             LT_EndGroup(Handle);
  522.         }
  523.  
  524.         if(PanelWindow = LT_Build(Handle,
  525.             LAWN_TitleID,        MSG_PENPANEL_SCREEN_DRAWING_PENS_TXT,
  526.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  527.             LAWN_HelpHook,        &GuideHook,
  528.             LAWN_Parent,        Window,
  529.             WA_DepthGadget,        TRUE,
  530.             WA_CloseGadget,        TRUE,
  531.             WA_DragBar,        TRUE,
  532.             WA_RMBTrap,        TRUE,
  533.             WA_Activate,        TRUE,
  534.             WA_SimpleRefresh,    TRUE,
  535.         TAG_DONE))
  536.         {
  537.             struct IntuiMessage    *Message;
  538.             BOOLEAN             Done = FALSE;
  539.             ULONG             MsgClass;
  540.             struct Gadget        *MsgGadget;
  541.             WORD             i;
  542.  
  543.             PushWindow(PanelWindow);
  544.  
  545.             LT_ShowWindow(Handle,TRUE);
  546.  
  547.             GuideContext(CONTEXT_SCREEN);
  548.  
  549.             do
  550.             {
  551.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  552.                     break;
  553.  
  554.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  555.                 {
  556.                     MsgClass    = Message -> Class;
  557.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  558.  
  559.                     LT_ReplyIMsg(Message);
  560.  
  561.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  562.                         Done = TRUE;
  563.  
  564.                     if(MsgClass == IDCMP_GADGETUP)
  565.                     {
  566.                         switch(MsgGadget -> GadgetID)
  567.                         {
  568.                             case GAD_USE:
  569.  
  570.                                 CopyMem(PrivateArray,Array,sizeof(PrivateArray));
  571.  
  572.                                 Array[DETAILPEN]    = PrivateArray[BACKGROUNDPEN];
  573.                                 Array[BLOCKPEN]        = PrivateArray[SHADOWPEN];
  574.                                 Array[BARTRIMPEN]    = PrivateArray[BARDETAILPEN];
  575.  
  576.                                 Result = Done = TRUE;
  577.                                 break;
  578.  
  579.                             case GAD_CANCEL:
  580.  
  581.                                 Done = TRUE;
  582.                                 break;
  583.  
  584.                             case GAD_DEFAULT:
  585.  
  586.                                 for(i = TEXTPEN ; i <= BARBLOCKPEN ; i++)
  587.                                     LT_SetAttributes(Handle,100 + i,GTPA_Color,DefaultArray[i],TAG_DONE);
  588.  
  589.                                 break;
  590.                         }
  591.                     }
  592.                 }
  593.             }
  594.             while(!Done);
  595.  
  596.             PopWindow();
  597.         }
  598.  
  599.         LT_DeleteHandle(Handle);
  600.     }
  601.  
  602.     return(Result);
  603. }
  604.  
  605. BYTE __regargs
  606. ScreenPanel(struct Configuration *LocalConfig,BYTE *Default)
  607. {
  608.     STATIC LONG PageTitleID[6] =
  609.     {
  610.         MSG_V36_0163,
  611.         MSG_V36_0164,
  612.         MSG_V36_0165,
  613.         MSG_V36_0166,
  614.         MSG_PENPANEL_DRAWING_PENS_TXT,
  615.         -1
  616.     };
  617.  
  618.     STATIC BYTE         InitialPage = 0;
  619.  
  620.     struct LayoutHandle    *Handle;
  621.     BYTE             UseIt = FALSE;
  622.     STRPTR             PageTitle[6];
  623.  
  624.     LocalizeStringTable(PageTitle,PageTitleID);
  625.  
  626.         // Make a backup of the current settings. We will modify only
  627.         // the backup
  628.  
  629.     SaveConfig(LocalConfig,PrivateConfig);
  630.  
  631.         // If the settings aren't yet patched up for 96 bit mode,
  632.         // do it now.
  633.  
  634.     if(!PrivateConfig -> ScreenConfig -> UseColours96)
  635.     {
  636.         Colour12x96(PrivateConfig -> ScreenConfig -> Colours,PrivateConfig -> ScreenConfig -> Colours96,16);
  637.  
  638.         PrivateConfig -> ScreenConfig -> UseColours96 = TRUE;
  639.     }
  640.  
  641.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  642.         LH_LocaleHook,    &LocaleHook,
  643.         LH_ExactClone,    TRUE,
  644.         LH_ExitFlush,    FALSE,
  645.     TAG_DONE))
  646.     {
  647.         struct Window    *LocalWindow;
  648.         UBYTE         ModeName[DISPLAYNAMELEN + 1],
  649.                  FontName[MAX_FILENAME_LENGTH];
  650.         ULONG         DisplayMode;
  651.         BOOL         FixedColours = CannotChangeColours(PrivateConfig,LocalConfig -> ScreenConfig -> ColourMode);
  652.  
  653.             // Get the desired screen display mode
  654.  
  655.         DisplayMode = PrivateConfig -> ScreenConfig -> DisplayMode;
  656.  
  657.             // Is the requested screen display mode available on this machine?
  658.  
  659.         if(ModeNotAvailable(DisplayMode))
  660.         {
  661.             struct Screen *PubScreen = LockPubScreen(NULL);
  662.  
  663.                 // Lock the default public screen
  664.  
  665.             if(PubScreen)
  666.             {
  667.                 struct DimensionInfo DimensionInfo;
  668.  
  669.                     // Use the default display mode
  670.  
  671.                 DisplayMode = GetVPModeID(&PubScreen -> ViewPort);
  672.  
  673.                     // Get the default screen size for this display mode
  674.  
  675.                 if(GetDisplayInfoData(NULL,(APTR)&DimensionInfo,sizeof(struct DimensionInfo),DTAG_DIMS,DisplayMode))
  676.                 {
  677.                     LONG    Width    = DimensionInfo . TxtOScan . MaxX - DimensionInfo . TxtOScan . MinX + 1,
  678.                         Height    = DimensionInfo . TxtOScan . MaxY - DimensionInfo . TxtOScan . MinY + 1;
  679.  
  680.                         // If the screen is set to a specific size, override
  681.                         // these settings with defaults.
  682.  
  683.                     if(Width != PrivateConfig -> ScreenConfig -> DisplayWidth && PrivateConfig -> ScreenConfig -> DisplayWidth > 0)
  684.                         PrivateConfig -> ScreenConfig -> DisplayWidth = Width;
  685.  
  686.                     if(Height != PrivateConfig -> ScreenConfig -> DisplayHeight && PrivateConfig -> ScreenConfig -> DisplayHeight > 0)
  687.                         PrivateConfig -> ScreenConfig -> DisplayHeight = Height;
  688.                 }
  689.  
  690.                 UnlockPubScreen(NULL,PubScreen);
  691.             }
  692.             else
  693.                 DisplayMode = DEFAULT_MONITOR_ID | HIRES_KEY;    // Catch all...
  694.         }
  695.  
  696.             // The name of the display mode chosen
  697.  
  698.         strcpy(ModeName,GetModeName(DisplayMode));
  699.  
  700.         BuildFontName(FontName,PrivateConfig -> ScreenConfig -> FontName,PrivateConfig -> ScreenConfig -> FontHeight);
  701.  
  702.             // If we cannot change the colours, or would
  703.             // display the wrong colours when choosing the
  704.             // rendering pens, don't display the last
  705.             // two pages
  706.  
  707.         if(FixedColours)
  708.         {
  709.             if(InitialPage > 2)
  710.                 InitialPage = 2;
  711.  
  712.             PageTitle[3] = NULL;
  713.         }
  714.  
  715.         if(!Kick30)
  716.         {
  717.             if(InitialPage > 3)
  718.                 InitialPage = 3;
  719.  
  720.             PageTitle[4] = NULL;
  721.         }
  722.  
  723.         LT_New(Handle,
  724.             LA_Type,    VERTICAL_KIND,
  725.         TAG_DONE);
  726.         {
  727.             LT_New(Handle,
  728.                 LA_Type,VERTICAL_KIND,
  729.             TAG_DONE);
  730.             {
  731.                 LT_New(Handle,
  732.                     LA_Type,    TAB_KIND,
  733.                     LA_ID,        GAD_PAGER,
  734.                     LA_LabelID,    MSG_XFER_PAGE_TXT,
  735.                     GTCY_Labels,    PageTitle,
  736.                     LACY_AutoPageID,GAD_PAGEGROUP,
  737.                     LACY_TabKey,    TRUE,
  738.                     LA_BYTE,    &InitialPage,
  739.                     LATB_FullWidth,    TRUE,
  740.                 TAG_DONE);
  741.  
  742.                 LT_EndGroup(Handle);
  743.             }
  744.  
  745.             LT_New(Handle,
  746.                 LA_Type,    VERTICAL_KIND,
  747.                 LA_ID,        GAD_PAGEGROUP,
  748.                 LAGR_ActivePage,InitialPage,
  749.             TAG_DONE);
  750.             {
  751.                 LT_New(Handle,
  752.                     LA_Type,    VERTICAL_KIND,
  753.                 TAG_DONE);
  754.                 {
  755.                     LT_New(Handle,
  756.                         LA_Type,    VERTICAL_KIND,
  757.                     TAG_DONE);
  758.                     {
  759.                         LT_New(Handle,
  760.                             LA_Type,    TEXT_KIND,
  761.                             LA_LabelID,    MSG_SCREENPANEL_CURRENT_DISPLAY_MODE_GAD,
  762.                             LA_Chars,    20,
  763.                             LA_ID,        GAD_SCREENMODE,
  764.                             GTTX_Text,    ModeName,
  765.                             GTTX_Border,    TRUE,
  766.                             LATX_Picker,    TRUE,
  767.                             LATX_LockSize,    TRUE,
  768.                         TAG_DONE);
  769.  
  770.                         LT_New(Handle,
  771.                             LA_Type,    TEXT_KIND,
  772.                             LA_LabelID,    MSG_SCREENPANEL_SCREEN_FONT_GAD,
  773.                             LA_Chars,    20,
  774.                             LA_ID,        GAD_FONT,
  775.                             GTTX_Text,    FontName,
  776.                             GTTX_Border,    TRUE,
  777.                             LATX_Picker,    TRUE,
  778.                             LATX_LockSize,    TRUE,
  779.                         TAG_DONE);
  780.  
  781.                         LT_EndGroup(Handle);
  782.                     }
  783.  
  784.                     LT_New(Handle,
  785.                         LA_Type,    VERTICAL_KIND,
  786.                     TAG_DONE);
  787.                     {
  788.                         if(Kick30)
  789.                         {
  790.                             LT_New(Handle,
  791.                                 LA_Type,    CHECKBOX_KIND,
  792.                                 LA_LabelID,    MSG_SCREENPANEL_FASTER_LAYOUT_GAD,
  793.                                 LA_BYTE,    &PrivateConfig -> ScreenConfig -> FasterLayout,
  794.                             TAG_DONE);
  795.                         }
  796.  
  797.                         LT_New(Handle,
  798.                             LA_Type,    CHECKBOX_KIND,
  799.                             LA_LabelID,    MSG_SCREENPANEL_MAKE_SCREEN_PUBLIC_GAD,
  800.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> MakeScreenPublic,
  801.                             LA_ID,        GAD_MAKESCREENPUBLIC,
  802.                             GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench,
  803.                         TAG_DONE);
  804.  
  805.                         LT_New(Handle,
  806.                             LA_Type,    CHECKBOX_KIND,
  807.                             LA_ID,        GAD_SHANGHAI,
  808.                             LA_LabelID,    MSG_SCREENPANEL_SHANGHAI_WINDOWS_GAD,
  809.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> ShanghaiWindows,
  810.                             GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench,
  811.                         TAG_DONE);
  812.  
  813.                         LT_EndGroup(Handle);
  814.                     }
  815.  
  816.                     LT_New(Handle,
  817.                         LA_Type,    VERTICAL_KIND,
  818.                     TAG_DONE);
  819.                     {
  820.                         LT_New(Handle,
  821.                             LA_Type,    XBAR_KIND,
  822.                         TAG_DONE);
  823.  
  824.                         LT_New(Handle,
  825.                             LA_Type,    CHECKBOX_KIND,
  826.                             LA_ID,        GAD_USE_PUBSCREEN,
  827.                             LA_LabelID,    MSG_SCREENPANEL_USE_WORKBENCH_GAD,
  828.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> UseWorkbench,
  829.                         TAG_DONE);
  830.  
  831.                         LT_EndGroup(Handle);
  832.                     }
  833.  
  834.                     LT_New(Handle,
  835.                         LA_Type,    VERTICAL_KIND,
  836.                     TAG_DONE);
  837.                     {
  838.                         LT_New(Handle,
  839.                             LA_Type,    STRING_KIND,
  840.                             LA_LabelID,    MSG_SCREENPANEL_PUBSCREEN_NAME_GAD,
  841.                             LA_ID,        GAD_PUBSCREENNAME,
  842.                             LA_STRPTR,    PrivateConfig -> ScreenConfig -> PubScreenName,
  843.                             LA_Chars,    14,
  844.                             GTST_MaxChars,    MAXPUBSCREENNAME,
  845.                             LAST_Picker,    TRUE,
  846.                             GA_Disabled,    !PrivateConfig -> ScreenConfig -> UseWorkbench,
  847.                         TAG_DONE);
  848.  
  849.                         LT_EndGroup(Handle);
  850.                     }
  851.  
  852.                     LT_EndGroup(Handle);
  853.                 }
  854.  
  855.                 LT_New(Handle,
  856.                     LA_Type,    VERTICAL_KIND,
  857.                 TAG_DONE);
  858.                 {
  859.                     LT_New(Handle,
  860.                         LA_Type,    VERTICAL_KIND,
  861.                     TAG_DONE);
  862.                     {
  863.                         LT_New(Handle,
  864.                             LA_Type,    CHECKBOX_KIND,
  865.                             LA_LabelID,    MSG_SCREENPANEL_SCREEN_TITLE_GAD,
  866.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> TitleBar,
  867.                             LA_ID,        GAD_SCREENTITLE,
  868.                             GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench,
  869.                         TAG_DONE);
  870.  
  871.                         LT_New(Handle,
  872.                             LA_Type,    CHECKBOX_KIND,
  873.                             LA_LabelID,    MSG_SCREENPANEL_WINDOW_BORDER_TXT,
  874.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> ShareScreen,
  875.                             LA_ID,        GAD_WINDOW_BORDER,
  876.                             GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench,
  877.                         TAG_DONE);
  878.  
  879.                         LT_New(Handle,
  880.                             LA_Type,    XBAR_KIND,
  881.                         TAG_DONE);
  882.  
  883.                         PrivateConfig -> ScreenConfig -> StatusLine &= 0xF;
  884.  
  885.                         LT_New(Handle,
  886.                             LA_Type,    CHECKBOX_KIND,
  887.                             LA_LabelID,    MSG_SCREENPANEL_SEPARATE_STATUS_WINDOW_TXT,
  888.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> SplitStatus,
  889.                             LA_ID,        GAD_SPLIT_STATUS,
  890.                             GA_Disabled,    !PrivateConfig -> ScreenConfig -> StatusLine || (!PrivateConfig -> ScreenConfig -> ShareScreen && !PrivateConfig -> ScreenConfig -> UseWorkbench),
  891.                         TAG_DONE);
  892.  
  893.                         LT_EndGroup(Handle);
  894.                     }
  895.  
  896.                     LT_New(Handle,
  897.                         LA_Type,    VERTICAL_KIND,
  898.                     TAG_DONE);
  899.                     {
  900.                         LT_New(Handle,
  901.                             LA_Type,    CYCLE_KIND,
  902.                             LA_LabelID,    MSG_SCREENPANEL_STATUS_LINE_GAD,
  903.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> StatusLine,
  904.                             LACY_FirstLabel,MSG_SCREENPANEL_STATUS_DISABLED_TXT,
  905.                             LACY_LastLabel,    MSG_SCREENPANEL_STATUS_COMPACT_TXT,
  906.                             LA_ID,        GAD_STATUS_LINE,
  907.                         TAG_DONE);
  908.  
  909.                         LT_New(Handle,
  910.                             LA_Type,    CYCLE_KIND,
  911.                             LA_LabelID,    MSG_SCREENPANEL_ONLINE_TIME_GAD,
  912.                             LA_BYTE,    &PrivateConfig -> ScreenConfig -> TimeMode,
  913.                             LACY_FirstLabel,MSG_SCREENPANEL_TIME_ONLINETIME_TXT,
  914.                             LACY_LastLabel,    MSG_SCREENPANEL_TIME_BOTH_TXT,
  915.                         TAG_DONE);
  916.  
  917.                         LT_EndGroup(Handle);
  918.                     }
  919.  
  920.                     LT_EndGroup(Handle);
  921.                 }
  922.  
  923.                 LT_New(Handle,
  924.                     LA_Type,    VERTICAL_KIND,
  925.                 TAG_DONE);
  926.                 {
  927.                     LT_New(Handle,
  928.                         LA_Type,    MX_KIND,
  929.                         LA_LabelID,    MSG_SCREENPANEL_COLOUR_GAD,
  930.                         LA_WORD,    &PrivateConfig -> ScreenConfig -> ColourMode,
  931.                         LA_ID,        GAD_COLOURMODE,
  932.                         LAMX_FirstLabel,MSG_SCREENPANEL_COLOUR_AMIGA_TXT,
  933.                         LAMX_LastLabel,    MSG_SCREENPANEL_COLOUR_MONO_TXT,
  934.                     TAG_DONE);
  935.  
  936.                     LT_New(Handle,
  937.                         LA_Type,    CHECKBOX_KIND,
  938.                         LA_LabelID,    MSG_SCREENPANEL_BLINKING_GAD,
  939.                         LA_ID,        GAD_BLINKING,
  940.                         LA_BYTE,    &PrivateConfig -> ScreenConfig -> Blinking,
  941.                         GA_Disabled,    PrivateConfig -> ScreenConfig -> ColourMode == COLOUR_MONO,
  942.                         LA_ExtraSpace,    TRUE,
  943.                     TAG_DONE);
  944.  
  945.                     LT_EndGroup(Handle);
  946.                 }
  947.  
  948.                 if(!FixedColours)
  949.                 {
  950.                     LT_New(Handle,
  951.                         LA_Type,    VERTICAL_KIND,
  952.                     TAG_DONE);
  953.                     {
  954.                         LONG Depth;
  955.  
  956.                         switch(PrivateConfig -> ScreenConfig -> ColourMode)
  957.                         {
  958.                             case COLOUR_MONO:
  959.  
  960.                                 Depth = 1;
  961.                                 break;
  962.  
  963.                             case COLOUR_AMIGA:
  964.  
  965.                                 Depth = 2;
  966.                                 break;
  967.  
  968.                             case COLOUR_EIGHT:
  969.  
  970.                                 Depth = 3;
  971.                                 break;
  972.  
  973.                             case COLOUR_SIXTEEN:
  974.  
  975.                                 Depth = 4;
  976.                                 break;
  977.                         }
  978.  
  979.                         if(PrivateConfig -> ScreenConfig -> UseWorkbench)
  980.                         {
  981.                             LONG i,MaxDepth = 4;
  982.  
  983.                             for(i = 0 ; i < 4 ; i++)
  984.                             {
  985.                                 if((1L << i) > Window -> WScreen -> ViewPort . ColorMap -> Count)
  986.                                 {
  987.                                     MaxDepth = i;
  988.  
  989.                                     break;
  990.                                 }
  991.                             }
  992.  
  993.                             if(Depth > MaxDepth)
  994.                                 Depth = MaxDepth;
  995.                         }
  996.  
  997.                         LT_New(Handle,
  998.                             LA_Type,    VERTICAL_KIND,
  999.                         TAG_DONE);
  1000.                         {
  1001.                             WORD    ColourMax;
  1002.                             STRPTR    ColourFormat;
  1003.  
  1004.                             if(Kick30)
  1005.                             {
  1006.                                 ColourMax    = 255;
  1007.                                 ColourFormat    = "%3ld";
  1008.                             }
  1009.                             else
  1010.                             {
  1011.                                 ColourMax    = 15;
  1012.                                 ColourFormat    = "%2ld";
  1013.                             }
  1014.  
  1015.                             LT_New(Handle,
  1016.                                 LA_Type,    PALETTE_KIND,
  1017.                                 LA_LabelID,    MSG_SCREENPANEL_EDIT_SCREEN_PALETTE_GAD,
  1018.                                 LA_ID,        GAD_PALETTE,
  1019.                                 LA_Chars,    12,
  1020.                                 GTPA_Depth,    Depth,
  1021.                             TAG_DONE);
  1022.  
  1023.                             LT_New(Handle,
  1024.                                 LA_Type,        SliderType,
  1025.                                 LA_LabelID,        MSG_SCREENPANEL_RED_GAD,
  1026.                                 LA_ID,            GAD_RED,
  1027.                                 GTSL_Min,        0,
  1028.                                 GTSL_Max,        ColourMax,
  1029.                                 GTSL_Level,        0,
  1030.                                 GTSL_LevelFormat,    ColourFormat,
  1031.                             TAG_DONE);
  1032.  
  1033.                             LT_New(Handle,
  1034.                                 LA_Type,        SliderType,
  1035.                                 LA_LabelID,        MSG_SCREENPANEL_GREEN_GAD,
  1036.                                 LA_ID,            GAD_GREEN,
  1037.                                 GTSL_Min,        0,
  1038.                                 GTSL_Max,        ColourMax,
  1039.                                 GTSL_Level,        0,
  1040.                                 GTSL_LevelFormat,    ColourFormat,
  1041.                             TAG_DONE);
  1042.  
  1043.                             LT_New(Handle,
  1044.                                 LA_Type,        SliderType,
  1045.                                 LA_LabelID,        MSG_SCREENPANEL_BLUE_GAD,
  1046.                                 LA_ID,            GAD_BLUE,
  1047.                                 GTSL_Min,        0,
  1048.                                 GTSL_Max,        ColourMax,
  1049.                                 GTSL_Level,        0,
  1050.                                 GTSL_LevelFormat,    ColourFormat,
  1051.                             TAG_DONE);
  1052.  
  1053.                             LT_New(Handle,
  1054.                                 LA_Type,        XBAR_KIND,
  1055.                             TAG_DONE);
  1056.  
  1057.                             LT_EndGroup(Handle);
  1058.                         }
  1059.  
  1060.                         LT_New(Handle,
  1061.                             LA_Type,    VERTICAL_KIND,
  1062.                         TAG_DONE);
  1063.                         {
  1064.                             LT_New(Handle,
  1065.                                 LA_Type,    BUTTON_KIND,
  1066.                                 LA_LabelID,    MSG_SCREENPANEL_USE_DEFAULT_TXT,
  1067.                                 LA_ID,        GAD_RESET,
  1068.                                 LA_Chars,    16,
  1069.                             TAG_DONE);
  1070.  
  1071.                             LT_EndGroup(Handle);
  1072.                         }
  1073.  
  1074.                         LT_EndGroup(Handle);
  1075.                     }
  1076.  
  1077.                     if(Kick30)
  1078.                     {
  1079.                         LT_New(Handle,
  1080.                             LA_Type,    VERTICAL_KIND,
  1081.                         TAG_DONE);
  1082.                         {
  1083.                             LT_New(Handle,
  1084.                                 LA_Type,    VERTICAL_KIND,
  1085.                             TAG_DONE);
  1086.                             {
  1087.                                 LT_New(Handle,
  1088.                                     LA_Type,    CHECKBOX_KIND,
  1089.                                     LA_LabelID,    MSG_PENPANEL_STANDARDPENS_TXT,
  1090.                                     LA_ID,        GAD_STDPENS,
  1091.                                     LA_BYTE,    &PrivateConfig -> ScreenConfig -> UsePens,
  1092.                                     GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench,
  1093.                                 TAG_DONE);
  1094.  
  1095.                                 LT_EndGroup(Handle);
  1096.                             }
  1097.  
  1098.                             LT_New(Handle,
  1099.                                 LA_Type,    VERTICAL_KIND,
  1100.                             TAG_DONE);
  1101.                             {
  1102.                                 LT_New(Handle,
  1103.                                     LA_Type,    BUTTON_KIND,
  1104.                                     LA_LabelID,    MSG_PENPANEL_EDITPENS_TXT,
  1105.                                     LA_ID,        GAD_EDITPENS,
  1106.                                     GA_Disabled,    PrivateConfig -> ScreenConfig -> UsePens || PrivateConfig -> ScreenConfig -> UseWorkbench,
  1107.                                 TAG_DONE);
  1108.  
  1109.                                 LT_EndGroup(Handle);
  1110.                             }
  1111.  
  1112.                             LT_EndGroup(Handle);
  1113.                         }
  1114.                     }
  1115.                 }
  1116.  
  1117.                 LT_EndGroup(Handle);
  1118.             }
  1119.  
  1120.             LT_New(Handle,
  1121.                 LA_Type,    VERTICAL_KIND,
  1122.             TAG_DONE);
  1123.             {
  1124.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  1125.  
  1126.                 LT_EndGroup(Handle);
  1127.             }
  1128.  
  1129.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  1130.                 LAGR_SameSize,    TRUE,
  1131.                 LAGR_Spread,    TRUE,
  1132.             TAG_DONE);
  1133.             {
  1134.                 LT_New(Handle,
  1135.                     LA_Type,    BUTTON_KIND,
  1136.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  1137.                     LA_ID,        GAD_USE,
  1138.                     LABT_ReturnKey,    TRUE,
  1139.                     LABT_ExtraFat,    TRUE,
  1140.                 TAG_DONE);
  1141.  
  1142.                 if(Default)
  1143.                 {
  1144.                     LT_New(Handle,
  1145.                         LA_Type,    BUTTON_KIND,
  1146.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  1147.                         LA_ID,        GAD_DEFAULT,
  1148.                         LABT_ExtraFat,    TRUE,
  1149.                     TAG_DONE);
  1150.                 }
  1151.  
  1152.                 LT_New(Handle,
  1153.                     LA_Type,    BUTTON_KIND,
  1154.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  1155.                     LA_ID,        GAD_CANCEL,
  1156.                     LABT_EscKey,    TRUE,
  1157.                     LABT_ExtraFat,    TRUE,
  1158.                 TAG_DONE);
  1159.  
  1160.                 LT_EndGroup(Handle);
  1161.             }
  1162.  
  1163.             LT_EndGroup(Handle);
  1164.         }
  1165.  
  1166.         if(LocalWindow = LT_Build(Handle,
  1167.             LAWN_TitleID,        MSG_SCREENPANEL_SCREEN_PREFERENCES_TXT,
  1168.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  1169.             LAWN_HelpHook,        &GuideHook,
  1170.             LAWN_Parent,        Window,
  1171.             WA_DepthGadget,        TRUE,
  1172.             WA_CloseGadget,        TRUE,
  1173.             WA_DragBar,        TRUE,
  1174.             WA_RMBTrap,        TRUE,
  1175.             WA_Activate,        TRUE,
  1176.             WA_SimpleRefresh,    TRUE,
  1177.         TAG_DONE))
  1178.         {
  1179.             struct IntuiMessage    *Message;
  1180.             BOOLEAN             Done = FALSE;
  1181.             ULONG             MsgClass;
  1182.             UWORD             MsgCode;
  1183.             struct Gadget        *MsgGadget;
  1184.  
  1185.             WORD             ColourNumber = 0,Count,i;
  1186.             WORD             Red,Green,Blue;
  1187.             struct ViewPort        *LocalVPort = &LocalWindow -> WScreen -> ViewPort;
  1188.             UWORD            *DefaultPens,Depth;
  1189.  
  1190.             switch(PrivateConfig -> ScreenConfig -> ColourMode)
  1191.             {
  1192.                 case COLOUR_MONO:
  1193.  
  1194.                     DefaultPens = MonoPens;
  1195.                     Depth = 1;
  1196.                     break;
  1197.  
  1198.                 case COLOUR_AMIGA:
  1199.  
  1200.                     DefaultPens = StandardPens;
  1201.                     Depth = 2;
  1202.                     break;
  1203.  
  1204.                 case COLOUR_EIGHT:
  1205.  
  1206.                     DefaultPens = ANSIPens;
  1207.                     Depth = 3;
  1208.                     break;
  1209.  
  1210.                 case COLOUR_SIXTEEN:
  1211.  
  1212.                     if(Kick30)
  1213.                         DefaultPens = NewEGAPens;
  1214.                     else
  1215.                         DefaultPens = EGAPens;
  1216.  
  1217.                     Depth = 4;
  1218.                     break;
  1219.             }
  1220.  
  1221.             for(Count = 0, i = DETAILPEN ; i <= BARTRIMPEN ; i++)
  1222.             {
  1223.                 if(PrivateConfig -> ScreenConfig -> PenArray[i])
  1224.                     Count++;
  1225.             }
  1226.  
  1227.             if(!Count)
  1228.                 CopyMem(DefaultPens,PrivateConfig -> ScreenConfig -> PenArray,16 * sizeof(UWORD));
  1229.  
  1230.             PrivateConfig -> ScreenConfig -> DisplayMode = DisplayMode;
  1231.  
  1232.             if(!FixedColours)
  1233.             {
  1234.                 if(Kick30)
  1235.                 {
  1236.                     Red    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 0] >> 24;
  1237.                     Green    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 1] >> 24;
  1238.                     Blue    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 2] >> 24;
  1239.                 }
  1240.                 else
  1241.                 {
  1242.                     Red    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 8) & 0xF;
  1243.                     Green    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 4) & 0xF;
  1244.                     Blue    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber]     ) & 0xF;
  1245.                 }
  1246.  
  1247.                 LT_SetAttributes(Handle,GAD_RED,    GTSL_Level,    Red,    TAG_DONE);
  1248.                 LT_SetAttributes(Handle,GAD_GREEN,    GTSL_Level,    Green,    TAG_DONE);
  1249.                 LT_SetAttributes(Handle,GAD_BLUE,    GTSL_Level,    Blue,    TAG_DONE);
  1250.  
  1251.                 PaletteSetup(PrivateConfig);
  1252.  
  1253.                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1254.                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1255.             }
  1256.  
  1257.             GuideContext(CONTEXT_SCREEN);
  1258.  
  1259.             PushWindow(LocalWindow);
  1260.  
  1261.             LT_ShowWindow(Handle,TRUE);
  1262.  
  1263.             do
  1264.             {
  1265.                 if(Wait(PORTMASK(LocalWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  1266.                     break;
  1267.  
  1268.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  1269.                 {
  1270.                     MsgClass    = Message -> Class;
  1271.                     MsgCode        = Message -> Code;
  1272.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  1273.  
  1274.                     LT_ReplyIMsg(Message);
  1275.  
  1276.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  1277.                         Done = TRUE;
  1278.  
  1279.                     if(MsgClass == IDCMP_GADGETUP || MsgClass == IDCMP_MOUSEMOVE || MsgClass == IDCMP_GADGETDOWN)
  1280.                     {
  1281.                         switch(MsgGadget -> GadgetID)
  1282.                         {
  1283.                             case GAD_RED:
  1284.  
  1285.                                 if(Kick30)
  1286.                                     Red = MsgCode;
  1287.                                 else
  1288.                                     Red = (MsgCode << 4) | MsgCode;
  1289.  
  1290.                                 PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 0] = SPREAD(Red);
  1291.  
  1292.                                 PaletteSetup(PrivateConfig);
  1293.  
  1294.                                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1295.                                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1296.  
  1297.                                 break;
  1298.  
  1299.                             case GAD_GREEN:
  1300.  
  1301.                                 if(Kick30)
  1302.                                     Green = MsgCode;
  1303.                                 else
  1304.                                     Green = (MsgCode << 4) | MsgCode;
  1305.  
  1306.                                 PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 1] = SPREAD(Green);
  1307.  
  1308.                                 PaletteSetup(PrivateConfig);
  1309.  
  1310.                                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1311.                                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1312.  
  1313.                                 break;
  1314.  
  1315.                             case GAD_BLUE:
  1316.  
  1317.                                 if(Kick30)
  1318.                                     Blue = MsgCode;
  1319.                                 else
  1320.                                     Blue = (MsgCode << 4) | MsgCode;
  1321.  
  1322.                                 PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 2] = SPREAD(Blue);
  1323.  
  1324.                                 PaletteSetup(PrivateConfig);
  1325.  
  1326.                                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1327.                                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1328.  
  1329.                                 break;
  1330.  
  1331.                             case GAD_STDPENS:
  1332.  
  1333.                                 LT_SetAttributes(Handle,GAD_EDITPENS,
  1334.                                     GA_Disabled,PrivateConfig -> ScreenConfig -> UsePens || PrivateConfig -> ScreenConfig -> UseWorkbench || FixedColours,
  1335.                                 TAG_DONE);
  1336.  
  1337.                                 break;
  1338.  
  1339.                             case GAD_USE_PUBSCREEN:
  1340.  
  1341.                                 LT_SetAttributes(Handle,GAD_PUBSCREENNAME,    GA_Disabled,!PrivateConfig -> ScreenConfig -> UseWorkbench,TAG_DONE);
  1342.                                 LT_SetAttributes(Handle,GAD_MAKESCREENPUBLIC,    GA_Disabled,PrivateConfig -> ScreenConfig -> UseWorkbench,TAG_DONE);
  1343.                                 LT_SetAttributes(Handle,GAD_SHANGHAI,        GA_Disabled,PrivateConfig -> ScreenConfig -> UseWorkbench,TAG_DONE);
  1344.                                 LT_SetAttributes(Handle,GAD_SCREENTITLE,    GA_Disabled,PrivateConfig -> ScreenConfig -> UseWorkbench,TAG_DONE);
  1345.                                 LT_SetAttributes(Handle,GAD_WINDOW_BORDER,    GA_Disabled,PrivateConfig -> ScreenConfig -> UseWorkbench,TAG_DONE);
  1346.                                 LT_SetAttributes(Handle,GAD_BLINKING,        GA_Disabled,PrivateConfig -> ScreenConfig -> ColourMode == COLOUR_MONO,TAG_DONE);
  1347.                                 LT_SetAttributes(Handle,GAD_SPLIT_STATUS,    GA_Disabled,!PrivateConfig -> ScreenConfig -> StatusLine || (!PrivateConfig -> ScreenConfig -> ShareScreen && !PrivateConfig -> ScreenConfig -> UseWorkbench),TAG_DONE);
  1348.  
  1349.                                 FixedColours = CannotChangeColours(PrivateConfig,LocalConfig -> ScreenConfig -> ColourMode);
  1350.  
  1351.                                 LT_SetAttributes(Handle,GAD_PALETTE,        GA_Disabled,FixedColours,TAG_DONE);
  1352.                                 LT_SetAttributes(Handle,GAD_RED,        GA_Disabled,FixedColours,TAG_DONE);
  1353.                                 LT_SetAttributes(Handle,GAD_GREEN,        GA_Disabled,FixedColours,TAG_DONE);
  1354.                                 LT_SetAttributes(Handle,GAD_BLUE,        GA_Disabled,FixedColours,TAG_DONE);
  1355.                                 LT_SetAttributes(Handle,GAD_RESET,        GA_Disabled,FixedColours,TAG_DONE);
  1356.  
  1357.                                 LT_SetAttributes(Handle,GAD_EDITPENS,
  1358.                                     GA_Disabled,    PrivateConfig -> ScreenConfig -> UsePens || PrivateConfig -> ScreenConfig -> UseWorkbench || FixedColours,
  1359.                                 TAG_DONE);
  1360.  
  1361.                                 LT_SetAttributes(Handle,GAD_STDPENS,
  1362.                                     GTCB_Checked,    PrivateConfig -> ScreenConfig -> UsePens = TRUE,
  1363.                                     GA_Disabled,    PrivateConfig -> ScreenConfig -> UseWorkbench || FixedColours,
  1364.                                 TAG_DONE);
  1365.  
  1366.                                 break;
  1367.  
  1368.                             case GAD_WINDOW_BORDER:
  1369.  
  1370.                                 LT_SetAttributes(Handle,GAD_SPLIT_STATUS,GA_Disabled,!PrivateConfig -> ScreenConfig -> StatusLine || (!PrivateConfig -> ScreenConfig -> ShareScreen && !PrivateConfig -> ScreenConfig -> UseWorkbench),TAG_DONE);
  1371.                                 break;
  1372.  
  1373.                             case GAD_COLOURMODE:
  1374.  
  1375.                                 if(!ModeOkay(PrivateConfig -> ScreenConfig -> DisplayMode) && PrivateConfig -> ScreenConfig -> ColourMode > COLOUR_AMIGA)
  1376.                                     LT_SetAttributes(Handle,GAD_COLOURMODE,GTCY_Active,COLOUR_AMIGA,TAG_DONE);
  1377.  
  1378.                                 FixedColours = CannotChangeColours(PrivateConfig,LocalConfig -> ScreenConfig -> ColourMode);
  1379.  
  1380.                                 LT_SetAttributes(Handle,GAD_PALETTE,    GA_Disabled,FixedColours,TAG_DONE);
  1381.                                 LT_SetAttributes(Handle,GAD_RED,    GA_Disabled,FixedColours,TAG_DONE);
  1382.                                 LT_SetAttributes(Handle,GAD_GREEN,    GA_Disabled,FixedColours,TAG_DONE);
  1383.                                 LT_SetAttributes(Handle,GAD_BLUE,    GA_Disabled,FixedColours,TAG_DONE);
  1384.                                 LT_SetAttributes(Handle,GAD_RESET,    GA_Disabled,FixedColours,TAG_DONE);
  1385.                                 LT_SetAttributes(Handle,GAD_BLINKING,    GA_Disabled,PrivateConfig -> ScreenConfig -> ColourMode == COLOUR_MONO,TAG_DONE);
  1386.  
  1387.                                 switch(PrivateConfig -> ScreenConfig -> ColourMode)
  1388.                                 {
  1389.                                     case COLOUR_MONO:
  1390.  
  1391.                                         DefaultPens = MonoPens;
  1392.                                         Depth = 1;
  1393.                                         break;
  1394.  
  1395.                                     case COLOUR_AMIGA:
  1396.  
  1397.                                         DefaultPens = StandardPens;
  1398.                                         Depth = 2;
  1399.                                         break;
  1400.  
  1401.                                     case COLOUR_EIGHT:
  1402.  
  1403.                                         DefaultPens = ANSIPens;
  1404.                                         Depth = 3;
  1405.                                         break;
  1406.  
  1407.                                     case COLOUR_SIXTEEN:
  1408.  
  1409.                                         DefaultPens = EGAPens;
  1410.                                         Depth = 4;
  1411.                                         break;
  1412.                                 }
  1413.  
  1414.                                 LT_SetAttributes(Handle,GAD_EDITPENS,
  1415.                                     GA_Disabled,    FixedColours,
  1416.                                 TAG_DONE);
  1417.  
  1418.                                 LT_SetAttributes(Handle,GAD_STDPENS,
  1419.                                     GA_Disabled,    FixedColours,
  1420.                                 TAG_DONE);
  1421.  
  1422.                                 Default2CurrentPalette(PrivateConfig);
  1423.  
  1424.                                 break;
  1425.  
  1426.                             case GAD_EDITPENS:
  1427.  
  1428.                                 LT_LockWindow(LocalWindow);
  1429.  
  1430.                                 if(PrivateConfig -> ScreenConfig -> PenColourMode != PrivateConfig -> ScreenConfig -> ColourMode)
  1431.                                 {
  1432.                                     UWORD LocalPens[16];
  1433.  
  1434.                                     CopyMem(DefaultPens,LocalPens,16 * sizeof(UWORD));
  1435.  
  1436.                                     if(PenPanel(LocalWindow,LocalPens,DefaultPens,Depth))
  1437.                                     {
  1438.                                         CopyMem(LocalPens,PrivateConfig -> ScreenConfig -> PenArray,16 * sizeof(UWORD));
  1439.  
  1440.                                         PrivateConfig -> ScreenConfig -> PenColourMode = PrivateConfig -> ScreenConfig -> ColourMode;
  1441.                                     }
  1442.                                 }
  1443.                                 else
  1444.                                     PenPanel(LocalWindow,PrivateConfig -> ScreenConfig -> PenArray,DefaultPens,Depth);
  1445.  
  1446.                                 LT_UnlockWindow(LocalWindow);
  1447.  
  1448.                                 LT_ShowWindow(Handle,TRUE);
  1449.                                 break;
  1450.  
  1451.                             case GAD_MAKESCREENPUBLIC:
  1452.  
  1453.                                 LT_SetAttributes(Handle,GAD_SHANGHAI,
  1454.                                     GA_Disabled,    !PrivateConfig -> ScreenConfig -> MakeScreenPublic || PrivateConfig -> ScreenConfig -> UseWorkbench,
  1455.                                 TAG_DONE);
  1456.  
  1457.                                 break;
  1458.  
  1459.                             case GAD_PALETTE:
  1460.  
  1461.                                 ColourNumber = MsgCode;
  1462.  
  1463.                                 if(Kick30)
  1464.                                 {
  1465.                                     Red    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 0] >> 24;
  1466.                                     Green    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 1] >> 24;
  1467.                                     Blue    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 2] >> 24;
  1468.                                 }
  1469.                                 else
  1470.                                 {
  1471.                                     Red    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 8) & 0xF;
  1472.                                     Green    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 4) & 0xF;
  1473.                                     Blue    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber]     ) & 0xF;
  1474.                                 }
  1475.  
  1476.                                 LT_SetAttributes(Handle,GAD_RED,    GTSL_Level,    Red,    TAG_DONE);
  1477.                                 LT_SetAttributes(Handle,GAD_GREEN,    GTSL_Level,    Green,    TAG_DONE);
  1478.                                 LT_SetAttributes(Handle,GAD_BLUE,    GTSL_Level,    Blue,    TAG_DONE);
  1479.  
  1480.                                 break;
  1481.  
  1482.                             case GAD_RESET:
  1483.  
  1484.                                 Default2CurrentPalette(PrivateConfig);
  1485.  
  1486.                                 if(Kick30)
  1487.                                 {
  1488.                                     Red    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 0] >> 24;
  1489.                                     Green    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 1] >> 24;
  1490.                                     Blue    = PrivateConfig -> ScreenConfig -> Colours96[ColourNumber * 3 + 2] >> 24;
  1491.                                 }
  1492.                                 else
  1493.                                 {
  1494.                                     Red    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 8) & 0xF;
  1495.                                     Green    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber] >> 4) & 0xF;
  1496.                                     Blue    = (PrivateConfig -> ScreenConfig -> Colours[ColourNumber]     ) & 0xF;
  1497.                                 }
  1498.  
  1499.                                 LT_SetAttributes(Handle,GAD_RED,    GTSL_Level,    Red,    TAG_DONE);
  1500.                                 LT_SetAttributes(Handle,GAD_GREEN,    GTSL_Level,    Green,    TAG_DONE);
  1501.                                 LT_SetAttributes(Handle,GAD_BLUE,    GTSL_Level,    Blue,    TAG_DONE);
  1502.  
  1503.                                 PaletteSetup(PrivateConfig);
  1504.  
  1505.                                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1506.                                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1507.  
  1508.                                 break;
  1509.  
  1510.                             case GAD_USE:
  1511.  
  1512.                                 LT_UpdateStrings(Handle);
  1513.  
  1514.                                 if(!FixedColours)
  1515.                                     PaletteSetup(PrivateConfig);
  1516.                                 else
  1517.                                 {
  1518.                                     if(PrivateConfig -> ScreenConfig -> ColourMode != PrivateConfig -> ScreenConfig -> ColourMode)
  1519.                                         Default2CurrentPalette(PrivateConfig);
  1520.                                 }
  1521.  
  1522.                                 if(PrivateConfig -> ScreenConfig -> PenColourMode != PrivateConfig -> ScreenConfig -> ColourMode)
  1523.                                 {
  1524.                                     CopyMem(DefaultPens,PrivateConfig -> ScreenConfig -> PenArray,16 * sizeof(UWORD));
  1525.  
  1526.                                     PrivateConfig -> ScreenConfig -> PenColourMode = PrivateConfig -> ScreenConfig -> ColourMode;
  1527.                                 }
  1528.  
  1529.                                 UseIt = Done = TRUE;
  1530.                                 break;
  1531.  
  1532.                             case GAD_CANCEL:
  1533.  
  1534.                                 Done = TRUE;
  1535.                                 break;
  1536.  
  1537.                             case GAD_DEFAULT:
  1538.  
  1539.                                 UseIt = *Default = TRUE;
  1540.  
  1541.                                 Done = TRUE;
  1542.                                 break;
  1543.                         }
  1544.                     }
  1545.  
  1546.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  1547.                     {
  1548.                         switch(MsgGadget -> GadgetID)
  1549.                         {
  1550.                             case GAD_FONT:
  1551.  
  1552.                                 if(PickFont(LocalWindow,PrivateConfig -> ScreenConfig -> FontName,&PrivateConfig -> ScreenConfig -> FontHeight,FALSE))
  1553.                                 {
  1554.                                     BuildFontName(FontName,PrivateConfig -> ScreenConfig -> FontName,PrivateConfig -> ScreenConfig -> FontHeight);
  1555.  
  1556.                                     LT_SetAttributes(Handle,GAD_FONT,
  1557.                                         GTTX_Text,    FontName,
  1558.                                     TAG_DONE);
  1559.                                 }
  1560.  
  1561.                                 break;
  1562.  
  1563.                             case GAD_SCREENMODE:
  1564.  
  1565.                                 LT_LockWindow(LocalWindow);
  1566.  
  1567.                                 if(SelectDisplayMode(LocalWindow,&PrivateConfig -> ScreenConfig -> DisplayMode,PrivateConfig))
  1568.                                 {
  1569.                                     strcpy(ModeName,GetModeName(PrivateConfig -> ScreenConfig -> DisplayMode));
  1570.  
  1571.                                     LT_SetAttributes(Handle,GAD_SCREENMODE,GTTX_Text,ModeName,TAG_DONE);
  1572.                                 }
  1573.  
  1574.                                 LT_UnlockWindow(LocalWindow);
  1575.  
  1576.                                 LT_ShowWindow(Handle,TRUE);
  1577.  
  1578.                                 break;
  1579.  
  1580.                             case GAD_STATUS_LINE:
  1581.  
  1582.                                 LT_SetAttributes(Handle,GAD_SPLIT_STATUS,GA_Disabled,!PrivateConfig -> ScreenConfig -> StatusLine || (!PrivateConfig -> ScreenConfig -> ShareScreen && !PrivateConfig -> ScreenConfig -> UseWorkbench),TAG_DONE);
  1583.  
  1584.                                 break;
  1585.  
  1586.                             case GAD_PUBSCREENNAME:
  1587.  
  1588.                                 if(PrivateConfig -> ScreenConfig -> UseWorkbench)
  1589.                                 {
  1590.                                     UBYTE DummyBuffer[MAXPUBSCREENNAME + 1];
  1591.  
  1592.                                     LT_LockWindow(LocalWindow);
  1593.  
  1594.                                     strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,GAD_PUBSCREENNAME,TAG_DONE));
  1595.                                     strcpy(SharedBuffer,DummyBuffer);
  1596.  
  1597.                                     if(PickScreen(LocalWindow,DummyBuffer))
  1598.                                     {
  1599.                                         if(strcmp(DummyBuffer,SharedBuffer))
  1600.                                             LT_SetAttributes(Handle,GAD_PUBSCREENNAME,GTST_String,DummyBuffer,TAG_DONE);
  1601.                                     }
  1602.  
  1603.                                     LT_UnlockWindow(LocalWindow);
  1604.  
  1605.                                     LT_ShowWindow(Handle,TRUE);
  1606.                                 }
  1607.  
  1608.                                 break;
  1609.                         }
  1610.                     }
  1611.                 }
  1612.             }
  1613.             while(!Done);
  1614.  
  1615.             PopWindow();
  1616.  
  1617.             if(((UseIt && Config != LocalConfig) || (!UseIt && Config == LocalConfig)) && !Config -> ScreenConfig -> UseWorkbench && Screen)
  1618.             {
  1619.                 PaletteSetup(Config);
  1620.  
  1621.                 LoadColourTable(VPort,        NormalColourTable,NormalColours,PaletteSize);
  1622.                 LoadColourTable(LocalVPort,    NormalColourTable,NormalColours,PaletteSize);
  1623.             }
  1624.         }
  1625.  
  1626.         LT_DeleteHandle(Handle);
  1627.     }
  1628.  
  1629.     if(UseIt)
  1630.         SwapConfig(LocalConfig,PrivateConfig);
  1631.     else
  1632.         SaveConfig(LocalConfig,PrivateConfig);
  1633.  
  1634.     return(UseIt);
  1635. }
  1636.